package com.example.inventoryservice.task.nativetask;

import com.google.common.collect.Sets;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.stream.Collectors;

@Slf4j
@Component
public class ScheduledTasks {
        // 创建固定大小的线程池
      private ExecutorService executorService =  Executors.newFixedThreadPool(3);


    // 使用fixedRate，固定间隔执行（单位：毫秒）
//    @Scheduled(fixedDelay = 5000)
//    public void fixedRateTask() {
//        log.error("使用fixedRate，固定间隔执行（单位：毫秒）, time：{}", 5000);
//        System.out.println("主线程：" + Thread.currentThread().getName());
//        for (int i = 3; i > 0; i--) {
//            MyThreadTest myThreadTest = new MyThreadTest();
//            myThreadTest.run();
//        }
//    }
//
////    // 使用fixedDelay，任务完成后延迟执行
//    @Scheduled(fixedDelay = 3000)
//    public void fixDelayTask() throws InterruptedException {
//        Thread.sleep(5000);
//        log.error("使用fixedDelay，任务完成后延迟执行, time：{}", 3000);
//        Thread thread = new Thread(new MyRunnable());
//        thread.start();
//    }
//
//    // 使用initialDelay，首次执行延迟
//    @Scheduled(initialDelay = 3000, fixedDelay = 3000)
//    public void initialDelayTask() throws InterruptedException {
//        Thread.sleep(5000);
//        log.error("使用initialDelay，首次执行延迟, time：{}", 3000);
//
//        MyThreadCallable myThreadCallable = new MyThreadCallable();
//        FutureTask<String> futureTask = new FutureTask<>(myThreadCallable);
//        Thread thread = new Thread(futureTask);
//        thread.start();
//
//        try {
//            String  result = futureTask.get();
//            log.error("异步任务结果为: {}", result);
//        } catch (ExecutionException e) {
//            throw new RuntimeException(e);
//        }
//    }
//
//    // 使用cron表达式，灵活控制执行时间（每天早上8点执行）
//    @Scheduled(cron = "0 0 8 * * ?")
//    public void cronTask() {
//        log.error("使用initialDelay，首次执行延迟, time：{}", 3000);
//    }

//    @Async // 异步执行
//    @Scheduled(fixedRate = 1000)
//    public void asyncTask() throws InterruptedException {
//        Thread.sleep(2000);
//        log.error("异步任务 - 当前线程: " + Thread.currentThread().getName());
//        try {
//            Thread.sleep(1000);
//            Set<String> set1 = Set.of("apple", "banana", "orange", "pear");
//            Set<String> set2 = Set.of("banana", "elderberry", "fig");
//            Set<String> intersection = set1.stream().filter(set2::contains).collect(Collectors.toSet());
//            log.debug("两个集合的交集为: {}", intersection);
//
//            Sets.SetView<String> difference = Sets.difference(set1, set2);
//            log.debug("两个集合的差集为: {}", difference.immutableCopy());
//
//        } catch (InterruptedException e) {
//            log.error("异步任务异常: {}", e.getMessage());
//        }
//    }
    @Scheduled(fixedRate = 1000)
    public void asyncTask() throws InterruptedException {
        // 提交任务
        for (int i = 0; i < 5; i++) {
            int taskId = i;
            executorService.submit(() ->{
                log.error("异步任务 - 任务ID: {}, 当前线程: {}", taskId, Thread.currentThread().getName());

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
        }
        // 关闭线程池
        executorService.shutdown();
    }
}
